﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Xushre.WeiBoSDK {
    /// <summary>
    /// 微博客户端
    /// </summary>
    public partial class OClient2 {

        /// <summary>
        /// 获取最新的公共微博
        /// </summary>
        /// <param name="count">单页返回的记录条数，最大不超过200，默认为20。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesPublicTimeline(int count = 20) {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            data.Add("count", count);

            try {
                response = Get(API.OClient2.Statuses.PUBLIC_TIMELINE, data);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }

        /// <summary>
        /// 获取当前登录用户及其所关注用户的最新微博
        /// </summary>
        /// <param name="since_id">若指定此参数，则返回ID比since_id大的微博（即比since_id时间晚的微博），默认为0。</param>
        /// <param name="max_id">若指定此参数，则返回ID小于或等于max_id的微博，默认为0。</param>
        /// <param name="count">单页返回的记录条数，最大不超过100，默认为20。</param>
        /// <param name="page">返回结果的页码，默认为1。</param>
        /// <param name="base_app">是否只获取当前应用的数据。0为否（所有数据），1为是（仅当前应用），默认为0。</param>
        /// <param name="feature">过滤类型ID，0：全部、1：原创、2：图片、3：视频、4：音乐，默认为0。</param>
        /// <param name="trim_user">返回值中user字段开关，0：返回完整user字段、1：user字段仅返回user_id，默认为0。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesFriendsTimeline(Int64 since_id = 0, Int64 max_id = 0, int count = 20, int page = 1, int base_app = 0, int feature = 0, int trim_user = 0) {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            data.Add("since_id", since_id);
            data.Add("max_id", max_id);
            data.Add("count", count);
            data.Add("page", page);
            data.Add("base_app", base_app);
            data.Add("feature", feature);
            data.Add("trim_user", trim_user);

            try {
                response = Get(API.OClient2.Statuses.FRIENDS_TIMELINE, data);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }

        /// <summary>
        /// 获取当前登录用户及其所关注用户的最新微博
        /// </summary>
        /// <param name="since_id">若指定此参数，则返回ID比since_id大的微博（即比since_id时间晚的微博），默认为0。</param>
        /// <param name="max_id">若指定此参数，则返回ID小于或等于max_id的微博，默认为0。</param>
        /// <param name="count">单页返回的记录条数，最大不超过100，默认为20。</param>
        /// <param name="page">返回结果的页码，默认为1。</param>
        /// <param name="base_app">是否只获取当前应用的数据。0为否（所有数据），1为是（仅当前应用），默认为0。</param>
        /// <param name="feature">过滤类型ID，0：全部、1：原创、2：图片、3：视频、4：音乐，默认为0。</param>
        /// <param name="trim_user">返回值中user字段开关，0：返回完整user字段、1：user字段仅返回user_id，默认为0。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesHomeTimeline(Int64 since_id = 0, Int64 max_id = 0, int count = 20, int page = 1, int base_app = 0, int feature = 0, int trim_user = 0) {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            data.Add("since_id", since_id);
            data.Add("max_id", max_id);
            data.Add("count", count);
            data.Add("page", page);
            data.Add("base_app", base_app);
            data.Add("feature", feature);
            data.Add("trim_user", trim_user);

            try {
                response = Get(API.OClient2.Statuses.HOME_TIMELINE, data);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }

        /// <summary>
        /// 获取某个用户最新发表的微博列表
        /// </summary>
        /// <param name="uid">需要查询的用户ID。</param>
        /// <param name="screen_name">需要查询的用户昵称。</param>
        /// <param name="since_id">若指定此参数，则返回ID比since_id大的微博（即比since_id时间晚的微博），默认为0。</param>
        /// <param name="max_id">若指定此参数，则返回ID小于或等于max_id的微博，默认为0。</param>
        /// <param name="count">单页返回的记录条数，最大不超过100，默认为20。</param>
        /// <param name="page">返回结果的页码，默认为1。</param>
        /// <param name="base_app">是否只获取当前应用的数据。0为否（所有数据），1为是（仅当前应用），默认为0。</param>
        /// <param name="feature">过滤类型ID，0：全部、1：原创、2：图片、3：视频、4：音乐，默认为0。</param>
        /// <param name="trim_user">返回值中user字段开关，0：返回完整user字段、1：user字段仅返回user_id，默认为0。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesUserTimeline(Int64 uid = 0, string screen_name = null, Int64 since_id = 0, Int64 max_id = 0, int count = 20, int page = 1, int base_app = 0, int feature = 0, int trim_user = 0) {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            if (uid > 0) {
                data.Add("uid", uid);
            }

            if (!String.IsNullOrEmpty(screen_name)) {
                data.Add("screen_name", screen_name);
            }

            data.Add("since_id", since_id);
            data.Add("max_id", max_id);
            data.Add("count", count);
            data.Add("page", page);
            data.Add("base_app", base_app);
            data.Add("feature", feature);
            data.Add("trim_user", trim_user);

            try {
                response = Get(API.OClient2.Statuses.USER_TIMELINE, data);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }

        /// <summary>
        /// 获取用户发布的微博的ID
        /// </summary>
        /// <param name="uid">需要查询的用户ID。</param>
        /// <param name="screen_name">需要查询的用户昵称。</param>
        /// <param name="since_id">若指定此参数，则返回ID比since_id大的微博（即比since_id时间晚的微博），默认为0。</param>
        /// <param name="max_id">若指定此参数，则返回ID小于或等于max_id的微博，默认为0。</param>
        /// <param name="count">单页返回的记录条数，最大不超过100，默认为20。</param>
        /// <param name="page">返回结果的页码，默认为1。</param>
        /// <param name="base_app">是否只获取当前应用的数据。0为否（所有数据），1为是（仅当前应用），默认为0。</param>
        /// <param name="feature">过滤类型ID，0：全部、1：原创、2：图片、3：视频、4：音乐，默认为0。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesUserTimeLineIds(Int64 uid = 0, string screen_name = null, Int64 since_id = 0, Int64 max_id = 0, int count = 20, int page = 1, int base_app = 0, int feature = 0) {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            if (uid > 0) {
                data.Add("uid", uid);
            }

            if (!String.IsNullOrEmpty(screen_name)) {
                data.Add("screen_name", screen_name);
            }

            data.Add("since_id", since_id);
            data.Add("max_id", max_id);
            data.Add("count", count);
            data.Add("page", page);
            data.Add("base_app", base_app);
            data.Add("feature", feature);

            try {
                response = Get(API.OClient2.Statuses.USER_TIMELINE_IDS, data);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }

        /// <summary>
        /// 获取当前登录用户及其所关注用户的最新微博的ID
        /// </summary>
        /// <param name="since_id">若指定此参数，则返回ID比since_id大的微博（即比since_id时间晚的微博），默认为0。</param>
        /// <param name="max_id">若指定此参数，则返回ID小于或等于max_id的微博，默认为0。</param>
        /// <param name="count">单页返回的记录条数，最大不超过100，默认为20。</param>
        /// <param name="page">返回结果的页码，默认为1。</param>
        /// <param name="base_app">是否只获取当前应用的数据。0为否（所有数据），1为是（仅当前应用），默认为0。</param>
        /// <param name="feature">过滤类型ID，0：全部、1：原创、2：图片、3：视频、4：音乐，默认为0。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesFriendsTimelineIds(Int64 since_id = 0, Int64 max_id = 0, int count = 20, int page = 1, int base_app = 0, int feature = 0) {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            data.Add("since_id", since_id);
            data.Add("max_id", max_id);
            data.Add("count", count);
            data.Add("page", page);
            data.Add("base_app", base_app);
            data.Add("feature", feature);

            try {
                response = Get(API.OClient2.Statuses.FRIENDS_TIMELINE_IDS, data);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }

        /// <summary>
        /// 获取指定微博的转发微博列表
        /// </summary>
        /// <param name="id">需要查询的微博ID。</param>
        /// <param name="since_id">若指定此参数，则返回ID比since_id大的微博（即比since_id时间晚的微博），默认为0。</param>
        /// <param name="max_id">若指定此参数，则返回ID小于或等于max_id的微博，默认为0。</param>
        /// <param name="count">单页返回的记录条数，最大不超过200，默认为20。</param>
        /// <param name="page">返回结果的页码，默认为1。</param>
        /// <param name="filter_by_author">作者筛选类型，0：全部、1：我关注的人、2：陌生人，默认为0。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesRepostTimeline(Int64 id, Int64 since_id = 0, Int64 max_id = 0, int count = 20, int page = 1, int filter_by_author = 0) {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            data.Add("id", id);
            data.Add("max_id", max_id);
            data.Add("since_id", since_id);
            data.Add("count", count);
            data.Add("page", page);
            data.Add("filter_by_author", filter_by_author);

            try {
                response = Get(API.OClient2.Statuses.REPOST_TIMELINE, data);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }

        /// <summary>
        /// 获取一条原创微博的最新转发微博的ID
        /// </summary>
        /// <param name="id">需要查询的微博ID。</param>
        /// <param name="since_id">若指定此参数，则返回ID比since_id大的微博（即比since_id时间晚的微博），默认为0。</param>
        /// <param name="max_id">若指定此参数，则返回ID小于或等于max_id的微博，默认为0。</param>
        /// <param name="count">单页返回的记录条数，最大不超过200，默认为20。</param>
        /// <param name="page">返回结果的页码，默认为1。</param>
        /// <param name="filter_by_author">作者筛选类型，0：全部、1：我关注的人、2：陌生人，默认为0。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesRepostTimelineIds(Int64 id, Int64 since_id = 0, Int64 max_id = 0, int count = 20, int page = 1, int filter_by_author = 0) {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            data.Add("id", id);
            data.Add("max_id", max_id);
            data.Add("since_id", since_id);
            data.Add("count", count);
            data.Add("page", page);
            data.Add("filter_by_author", filter_by_author);

            try {
                response = Get(API.OClient2.Statuses.REPOST_TIMELINE_IDS, data);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }

        /// <summary>
        /// 获取当前用户最新转发的微博列表
        /// </summary>
        /// <param name="since_id">若指定此参数，则返回ID比since_id大的微博（即比since_id时间晚的微博），默认为0。</param>
        /// <param name="max_id">若指定此参数，则返回ID小于或等于max_id的微博，默认为0。</param>
        /// <param name="count">单页返回的记录条数，最大不超过200，默认为20。</param>
        /// <param name="page">返回结果的页码，默认为1。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesRepostByMe(Int64 since_id = 0, Int64 max_id = 0, int count = 20, int page = 1) {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            data.Add("max_id", max_id);
            data.Add("since_id", since_id);
            data.Add("count", count);
            data.Add("page", page);

            try {
                response = Get(API.OClient2.Statuses.REPOST_BY_ME, data);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }

        /// <summary>
        /// 获取@当前用户的最新微博
        /// </summary>
        /// <param name="since_id">若指定此参数，则返回ID比since_id大的微博（即比since_id时间晚的微博），默认为0。</param>
        /// <param name="max_id">若指定此参数，则返回ID小于或等于max_id的微博，默认为0。</param>
        /// <param name="count">单页返回的记录条数，最大不超过200，默认为20。</param>
        /// <param name="page">返回结果的页码，默认为1。</param>
        /// <param name="filter_by_author">作者筛选类型，0：全部、1：我关注的人、2：陌生人，默认为0。</param>
        /// <param name="filter_by_source">来源筛选类型，0：全部、1：来自微博、2：来自微群，默认为0。</param>
        /// <param name="filter_by_type">原创筛选类型，0：全部微博、1：原创的微博，默认为0。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesMentions(Int64 since_id = 0, Int64 max_id = 0, int count = 20, int page = 1, int filter_by_author = 0, int filter_by_source = 0, int filter_by_type = 0) {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            data.Add("max_id", max_id);
            data.Add("since_id", since_id);
            data.Add("count", count);
            data.Add("page", page);
            data.Add("filter_by_author", filter_by_author);
            data.Add("filter_by_source", filter_by_source);
            data.Add("filter_by_type", filter_by_type);

            try {
                response = Get(API.OClient2.Statuses.MENTIONS, data);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }

        /// <summary>
        /// 获取@当前用户的最新微博
        /// </summary>
        /// <param name="since_id">若指定此参数，则返回ID比since_id大的微博（即比since_id时间晚的微博），默认为0。</param>
        /// <param name="max_id">若指定此参数，则返回ID小于或等于max_id的微博，默认为0。</param>
        /// <param name="count">单页返回的记录条数，最大不超过200，默认为20。</param>
        /// <param name="page">返回结果的页码，默认为1。</param>
        /// <param name="filter_by_author">作者筛选类型，0：全部、1：我关注的人、2：陌生人，默认为0。</param>
        /// <param name="filter_by_source">来源筛选类型，0：全部、1：来自微博、2：来自微群，默认为0。</param>
        /// <param name="filter_by_type">原创筛选类型，0：全部微博、1：原创的微博，默认为0。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesMentionsIds(Int64 since_id = 0, Int64 max_id = 0, int count = 20, int page = 1, int filter_by_author = 0, int filter_by_source = 0, int filter_by_type = 0) {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            data.Add("max_id", max_id);
            data.Add("since_id", since_id);
            data.Add("count", count);
            data.Add("page", page);
            data.Add("filter_by_author", filter_by_author);
            data.Add("filter_by_source", filter_by_source);
            data.Add("filter_by_type", filter_by_type);

            try {
                response = Get(API.OClient2.Statuses.MENTIONS_IDS, data);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }

        /// <summary>
        /// 获取双向关注用户的最新微博
        /// </summary>
        /// <param name="since_id">若指定此参数，则返回ID比since_id大的微博（即比since_id时间晚的微博），默认为0。</param>
        /// <param name="max_id">若指定此参数，则返回ID小于或等于max_id的微博，默认为0。</param>
        /// <param name="count">单页返回的记录条数，最大不超过100，默认为20。</param>
        /// <param name="page">返回结果的页码，默认为1。</param>
        /// <param name="base_app">是否只获取当前应用的数据。0为否（所有数据），1为是（仅当前应用），默认为0。</param>
        /// <param name="feature">过滤类型ID，0：全部、1：原创、2：图片、3：视频、4：音乐，默认为0。</param>
        /// <param name="trim_user">返回值中user字段开关，0：返回完整user字段、1：user字段仅返回user_id，默认为0。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesBilateralTimeline(Int64 since_id = 0, Int64 max_id = 0, int count = 0, int page = 0, int base_app = 0, int feature = 0, int trim_user = 0) {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            data.Add("max_id", max_id);
            data.Add("since_id", since_id);
            data.Add("count", count);
            data.Add("page", page);
            data.Add("base_app", base_app);
            data.Add("feature", feature);
            data.Add("trim_user", trim_user);

            try {
                response = Get(API.OClient2.Statuses.BILATERAL_TIMELINE, data);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }

        /// <summary>
        /// 根据微博ID获取单条微博内容
        /// </summary>
        /// <param name="id">需要获取的微博ID。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesShow(Int64 id) {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            data.Add("id", id);

            try {
                response = Get(API.OClient2.Statuses.SHOW, data);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }

        /// <summary>
        /// 通过微博（评论、私信）ID获取其MID
        /// </summary>
        /// <param name="id">需要查询的微博（评论、私信）ID，批量模式下，用半角逗号分隔，最多不超过20个。</param>
        /// <param name="type">获取类型，1：微博、2：评论、3：私信，默认为1。</param>
        /// <param name="is_batch">是否使用批量模式，0：否、1：是，默认为0。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesQuerymid(Int64 id, int type = 1, int is_batch = 0) {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            data.Add("id", id);
            data.Add("type", type);
            data.Add("is_batch", is_batch);

            try {
                response = Get(API.OClient2.Statuses.QUERYMID, data);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }

        /// <summary>
        /// 通过微博（评论、私信）ID获取其MID
        /// </summary>
        /// <param name="id">需要查询的微博（评论、私信）ID，批量模式下，用半角逗号分隔，最多不超过20个。</param>
        /// <param name="type">获取类型，1：微博、2：评论、3：私信，默认为1。</param>
        /// <param name="is_batch">是否使用批量模式，0：否、1：是，默认为0。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesQuerymid(string id, int type = 1, int is_batch = 0) {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            data.Add("id", id);
            data.Add("type", type);
            data.Add("is_batch", is_batch);

            try {
                response = Get(API.OClient2.Statuses.QUERYMID, data);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }

        /// <summary>
        /// 通过微博（评论、私信）MID获取其ID
        /// </summary>
        /// <param name="mid">需要查询的微博（评论、私信）MID，批量模式下，用半角逗号分隔，最多不超过20个。</param>
        /// <param name="type">获取类型，1：微博、2：评论、3：私信，默认为1。</param>
        /// <param name="is_batch">是否使用批量模式，0：否、1：是，默认为0。</param>
        /// <param name="inbox">仅对私信有效，当MID类型为私信时用此参数，0：发件箱、1：收件箱，默认为0 。</param>
        /// <param name="isBase62">MID是否是base62编码，0：否、1：是，默认为0。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesId(string mid, int type = 1, int is_batch = 0, int inbox = 0, int isBase62 = 0) {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            data.Add("mid", mid);
            data.Add("type", type);
            data.Add("is_batch", is_batch);
            data.Add("inbox", inbox);
            data.Add("isBase62", isBase62);

            try {
                response = Get(API.OClient2.Statuses.QUERYID, data);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }

        /// <summary>
        /// 批量获取指定微博的转发数评论数
        /// </summary>
        /// <param name="ids">需要获取数据的微博ID，多个之间用逗号分隔，最多不超过100个。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesCount(string ids) {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            data.Add("ids", ids);

            try {
                response = Get(API.OClient2.Statuses.COUNT, data);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }

        /// <summary>
        /// 获取当前登录用户关注的人发给其的定向微博
        /// </summary>
        /// <param name="since_id">若指定此参数，则返回ID比since_id大的微博（即比since_id时间晚的微博），默认为0。</param>
        /// <param name="max_id">若指定此参数，则返回ID小于或等于max_id的微博，默认为0。</param>
        /// <param name="page">返回结果的页码，默认为1。</param>
        /// <param name="count">返回结果的条数数量，最大不超过200，默认为20。</param>
        /// <param name="trim_user">返回值中user字段开关，0：返回完整user字段、1：user字段仅返回uid，默认为0。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesToMe(Int64 since_id = 0, Int64 max_id = 0, int page = 1, int count = 20, int trim_user = 0) {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            data.Add("since_id", since_id);
            data.Add("max_id", max_id);
            data.Add("page", page);
            data.Add("count", count);
            data.Add("trim_user", trim_user);

            try {
                response = Get(API.OClient2.Statuses.TO_ME, data);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }

        /// <summary>
        /// 获取当前登录用户关注的人发给其的定向微博ID列表
        /// </summary>
        /// <param name="since_id">若指定此参数，则返回ID比since_id大的微博（即比since_id时间晚的微博），默认为0。</param>
        /// <param name="max_id">若指定此参数，则返回ID小于或等于max_id的微博，默认为0。</param>
        /// <param name="page">返回结果的页码，默认为1。</param>
        /// <param name="count">返回结果的条数数量，最大不超过200，默认为20。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesToMeIds(Int64 since_id = 0, Int64 max_id = 0, int page = 1, int count = 20) {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            data.Add("since_id", since_id);
            data.Add("max_id", max_id);
            data.Add("page", page);
            data.Add("count", count);

            try {
                response = Get(API.OClient2.Statuses.TO_ME_IDS, data);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }

        /// <summary>
        /// 根据ID跳转到单条微博页
        /// </summary>
        /// <param name="uid">需要跳转的用户ID。</param>
        /// <param name="id">需要跳转的微博ID。</param>
        /// <returns>
        /// 成功返回：无，跳转到指定的单条微博页
        /// 失败返回：无，跳转到微博首页
        /// </returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesGo(Int64 uid, Int64 id) {
            string url = API.OClient2.Statuses.GO;

            if (!String.IsNullOrEmpty(access_token)) {
                url += "?access_token=" + access_token;
            } else {
                url += "?source=" + source;
            }

            url += "&uid=" + uid;
            url += "&id=" + id;

            return url;
        }

        /// <summary>
        /// 获取微博官方表情的详细信息
        /// </summary>
        /// <param name="type">表情类别，face：普通表情、ani：魔法表情、cartoon：动漫表情，默认为face。</param>
        /// <param name="language">语言类别，cnname：简体、twname：繁体，默认为cnname。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesEmotions(string type = "face", string language = "cnname") {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            data.Add("type", type);
            data.Add("language", language);

            try {
                response = Get(API.OClient2.Statuses.EMOTIONS, data);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }


        /// <summary>
        /// 转发一条微博
        /// </summary>
        /// <param name="id">要转发的微博ID。</param>
        /// <param name="status">添加的转发文本，程序自动做URLencode处理，内容不超过140个汉字，超出部分自动裁减，不填则默认为“转发微博”。</param>
        /// <param name="is_comment">是否在转发的同时发表评论，0：否、1：评论给当前微博、2：评论给原微博、3：都评论，默认为0 。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesRepost(Int64 id, string status = "转发微博", int is_comment = 0) {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            if (Encoding.Default.GetByteCount(status) > 280) {

                // 非单字节
                if (Tools.isSingle(status)) {
                    status = status.Substring(0, 140);
                } else {
                    status = status.Substring(0, 280);
                }
            }

            data.Add("id", id);
            data.Add("status", status);
            data.Add("is_comment", is_comment);

            try {
                response = Post(API.OClient2.Statuses.REPOST, data);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }

        /// <summary>
        /// 根据微博ID删除指定微博
        /// </summary>
        /// <remarks>只能删除自己发布的微博</remarks>
        /// <param name="id">要删除的微博ID。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesDestory(Int64 id) {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            data.Add("id", id);

            try {
                response = Post(API.OClient2.Statuses.DESTORY, data);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }

        /// <summary>
        /// 发布一条新微博
        /// </summary>
        /// <remarks>连续两次发布的微博不可以重复；非会员发表定向微博，分组成员数最多200。</remarks>
        /// <param name="status">要发布的微博文本内容，必须做URLencode，内容不超过140个汉字。</param>
        /// <param name="visible">微博的可见性，0：所有人能看，1：仅自己可见，2：密友可见，3：指定分组可见，默认为0。</param>
        /// <param name="list_id">微博的保护投递指定分组ID，只有当visible参数为3时生效且必选。</param>
        /// <param name="lat">纬度，有效范围：-90.0到+90.0，+表示北纬，默认为0.0。</param>
        /// <param name="long_">经度，有效范围：-180.0到+180.0，+表示东经，默认为0.0。</param>
        /// <param name="annotations">元数据，主要是为了方便第三方应用记录一些适合于自己使用的信息，每条微博可以包含一个或者多个元数据，必须以json字串的形式提交，字串长度不超过512个字符，具体内容可以自定。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesUpdate(string status, int visible = 0, string list_id = null, float lat = 0.0f, float long_ = 0.0f, string annotations = null) {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            if (Encoding.Default.GetByteCount(status) > 280) {
                if (Tools.isSingle(status)) {
                    status = status.Substring(0, 140);
                } else {
                    status = status.Substring(0, 280);
                }
            }

            data.Add("status", status);
            data.Add("visible", visible);
            if (!String.IsNullOrEmpty(list_id)) {
                data.Add("list_id", list_id);
            }
            data.Add("lat", lat);
            data.Add("long", long_);
            if (!String.IsNullOrEmpty(annotations)) {
                data.Add("annotations", annotations);
            }

            try {
                response = Post(API.OClient2.Statuses.UPDATE, data);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }

        /// <summary>
        /// 上传图片并发布一条新微博
        /// </summary>
        /// <remarks>请求必须用POST方式提交，并且注意采用multipart/form-data编码方式；非会员发表定向微博，分组成员数最多200。</remarks>
        /// <param name="status">要发布的微博文本内容，必须做URLencode，内容不超过140个汉字。</param>
        /// <param name="pic">微博的可见性，0：所有人能看，1：仅自己可见，2：密友可见，3：指定分组可见，默认为0。</param>
        /// <param name="visible">微博的保护投递指定分组ID，只有当visible参数为3时生效且必选。</param>
        /// <param name="list_id">要上传的图片，仅支持JPEG、GIF、PNG格式，图片大小小于5M。</param>
        /// <param name="lat">纬度，有效范围：-90.0到+90.0，+表示北纬，默认为0.0。</param>
        /// <param name="long_">经度，有效范围：-180.0到+180.0，+表示东经，默认为0.0。</param>
        /// <param name="annotations">元数据，主要是为了方便第三方应用记录一些适合于自己使用的信息，每条微博可以包含一个或者多个元数据，必须以json字串的形式提交，字串长度不超过512个字符，具体内容可以自定。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesUpload(string status, string pic, int visible = 0, string list_id = null, float lat = 0.0f, float long_ = 0.0f, string annotations = null) {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            if (Encoding.Default.GetByteCount(status) > 280) {
                if (Tools.isSingle(status)) {
                    status = status.Substring(0, 140);
                } else {
                    status = status.Substring(0, 280);
                }
            }

            SetData(ref data);

            data.Add("status", status);
            data.Add("visible", visible);
            if (!String.IsNullOrEmpty(list_id)) {
                data.Add("list_id", list_id);
            }
            data.Add("lat", lat);
            data.Add("long", long_);
            if (!String.IsNullOrEmpty(annotations)) {
                data.Add("annotations", annotations);
            }

            Dictionary<string, string> file = new Dictionary<string, string>();
            file.Add("pic", pic);

            try {
                byte[] temp = Tools.UploadFile(API.OClient2.Statuses.UPLOAD, file, data, encoding);
                response = encoding.GetString(temp);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }

        /// <summary>
        /// 指定一个图片URL地址抓取后上传并同时发布一条新微博
        /// </summary>
        /// <remarks>连续两次发布的微博不可以重复；非会员发表定向微博，分组成员数最多200。</remarks>
        /// <param name="status">要发布的微博文本内容，必须做URLencode，内容不超过140个汉字。</param>
        /// <param name="visible">微博的可见性，0：所有人能看，1：仅自己可见，2：密友可见，3：指定分组可见，默认为0。</param>
        /// <param name="list_id">微博的保护投递指定分组ID，只有当visible参数为3时生效且必选。</param>
        /// <param name="url">图片的URL地址，必须以http开头。</param>
        /// <param name="lat">纬度，有效范围：-90.0到+90.0，+表示北纬，默认为0.0。</param>
        /// <param name="long_">经度，有效范围：-180.0到+180.0，+表示东经，默认为0.0。</param>
        /// <param name="annotations">元数据，主要是为了方便第三方应用记录一些适合于自己使用的信息，每条微博可以包含一个或者多个元数据，必须以json字串的形式提交，字串长度不超过512个字符，具体内容可以自定。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesUploadUrlText(string status = null, int visible = 0, string list_id = null, string url = null, float lat = 0.0f, float long_ = 0.0f, string annotations = null) {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            if (!String.IsNullOrEmpty(status) && Encoding.Default.GetByteCount(status) > 280) {
                if (Tools.isSingle(status)) {
                    status = status.Substring(0, 140);
                } else {
                    status = status.Substring(0, 280);
                }
            }
            data.Add("status", status);
            data.Add("visible", visible);
            data.Add("list_id", list_id);
            data.Add("url", url);
            data.Add("lat", lat);
            data.Add("long_", long_);

            if (!String.IsNullOrEmpty(annotations)) {
                data.Add("annotations", annotations);
            }

            try {
                response = Post(API.OClient2.Statuses.UPLOAD_URL_TEXT, data);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }

        /// <summary>
        /// 屏蔽某条微博
        /// </summary>
        /// <param name="id">微博id。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesFilterCreate(Int64 id) {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            data.Add("id", id);

            try {
                response = Post(API.OClient2.Statuses.FILTER_CREATE, data);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }

        /// <summary>
        /// 屏蔽某个@到我的微博以及后续由对其转发引起的@提及
        /// </summary>
        /// <param name="id">需要屏蔽的@提到我的微博ID。此ID必须在statuses/mentions列表中。</param>
        /// <param name="follow_up">是否仅屏蔽当前微博。0：仅屏蔽当前@提到我的微博；1：屏蔽当前@提到我的微博，以及后续对其转发而引起的@提到我的微博。默认1。</param>
        /// <returns>JSON 格式的客串</returns>
        /// <exception cref="WeiboException"></exception>
        public string StatusesMentionsShield(Int64 id, int follow_up = 1) {
            string response = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>();

            data.Add("id", id);
            data.Add("follow_up", follow_up);

            try {
                response = Post(API.OClient2.Statuses.MENTIONS_SHIELD, data);
            } catch (WeiboException e) {
                throw e;
            }

            return response;
        }
    }
}
